{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:43.188004Z",
     "start_time": "2025-01-17T02:16:43.183724Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:43.270002Z",
     "start_time": "2025-01-17T02:16:43.240561Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 36
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.304893Z",
     "start_time": "2025-01-17T02:16:43.270002Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds: # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205]) # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 37
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.313439Z",
     "start_time": "2025-01-17T02:16:47.305397Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            # print(m)\n",
    "            # print('-'*50)\n",
    "            if isinstance(m, nn.Linear):#判断m是否为全连接层\n",
    "                # https://pytorch.org/docs/stable/nn.init.html\n",
    "                nn.init.xavier_uniform_(m.weight) # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias) # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x) #标准化\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "total=0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total+=np.prod(value.shape)\n",
    "total #模型参数数量"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "271410"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 38
  },
  {
   "cell_type": "code",
   "source": [
    "w = torch.empty(3, 5)\n",
    "print(w)\n",
    "nn.init.eye_(w)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.319997Z",
     "start_time": "2025-01-17T02:16:47.313944Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-1.7012e+12,  1.0103e-42,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  1.4013e-45,  0.0000e+00,  0.0000e+00]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[1., 0., 0., 0., 0.],\n",
       "        [0., 1., 0., 0., 0.],\n",
       "        [0., 0., 1., 0., 0.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 39
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.323597Z",
     "start_time": "2025-01-17T02:16:47.319997Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 40
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.328208Z",
     "start_time": "2025-01-17T02:16:47.323597Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 41
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.331842Z",
     "start_time": "2025-01-17T02:16:47.328208Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 42
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.335351Z",
     "start_time": "2025-01-17T02:16:47.331842Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 43
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.341752Z",
     "start_time": "2025-01-17T02:16:47.335351Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n"
   ],
   "outputs": [],
   "execution_count": 44
  },
  {
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-17T02:16:47.391188Z",
     "start_time": "2025-01-17T02:16:47.342757Z"
    }
   },
   "outputs": [],
   "execution_count": 45
  },
  {
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-17T02:23:35.845215Z",
     "start_time": "2025-01-17T02:16:47.391188Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "13f52ff0ee024e30a5ce4e4ac869340e"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 29 / global_step 108750\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:23:35.958773Z",
     "start_time": "2025-01-17T02:23:35.845215Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 47
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:23:36.828927Z",
     "start_time": "2025-01-17T02:23:35.958773Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.4257\n",
      "accuracy: 0.8834\n"
     ]
    }
   ],
   "execution_count": 48
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
